org.springframework.core

Class ResolvableType

java.lang.Object

org.springframework.core.ResolvableType

All Implemented Interfaces:

java.io.Serializable

public class ResolvableType
extends java.lang.Object
implements java.io.Serializable

Encapsulates a Java Type, providing access to supertypes, interfaces, and generic parameters along with the ability to ultimately resolve to a Class.

ResolvableTypes may be obtained from fields, method parameters, method returns or classes. Most methods on this class will themselves return ResolvableTypes, allowing easy navigation. For example:

 private HashMap<Integer, List<String>> myMap;

 public void example() {
     ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
     t.getSuperType(); // AbstractMap<Integer, List<String>>
     t.asMap(); // Map<Integer, List<String>>
     t.getGeneric(0).resolve(); // Integer
     t.getGeneric(1).resolve(); // List
     t.getGeneric(1); // List<String>
     t.resolveGeneric(1, 0); // String
 }
 

Since:

4.0

Author:

Phillip Webb, Juergen Hoeller, Stephane Nicoll

See Also:

forField(Field), forMethodParameter(Method, int), forMethodReturnType(Method), forConstructorParameter(Constructor, int), forClass(Class), forType(Type), forInstance(Object), ResolvableTypeProvider, Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	ResolvableType.DefaultVariableResolver
(package private) static class	ResolvableType.EmptyType
private static class	ResolvableType.SyntheticParameterizedType
private static class	ResolvableType.TypeVariablesVariableResolver
(package private) static interface	ResolvableType.VariableResolver Strategy interface used to resolve TypeVariables.
private static class	ResolvableType.WildcardBounds Internal helper to handle bounds from WildcardTypes.

Field Summary

Fields

Modifier and Type	Field and Description
private static ConcurrentReferenceHashMap<ResolvableType,ResolvableType>	cache
private ResolvableType	componentType The component type for an array or null if the type should be deduced.
private static ResolvableType[]	EMPTY_TYPES_ARRAY
private ResolvableType[]	generics
private java.lang.Integer	hash
private ResolvableType[]	interfaces
static ResolvableType	NONE ResolvableType returned when no value is available.
private java.lang.Class<?>	resolved
private ResolvableType	superType
private java.lang.reflect.Type	type The underlying Java type being managed.
private SerializableTypeWrapper.TypeProvider	typeProvider Optional provider for the type.
private ResolvableType.VariableResolver	variableResolver The VariableResolver to use or null if no resolver is available.

Constructor Summary

Constructors

Modifier	Constructor and Description
private	ResolvableType(java.lang.Class<?> clazz) Private constructor used to create a new ResolvableType on a Class basis.
private	ResolvableType(java.lang.reflect.Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver) Private constructor used to create a new ResolvableType for cache key purposes, with no upfront resolution.
private	ResolvableType(java.lang.reflect.Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, java.lang.Integer hash) Private constructor used to create a new ResolvableType for cache value purposes, with upfront resolution and a pre-calculated hash.
private	ResolvableType(java.lang.reflect.Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, ResolvableType componentType) Private constructor used to create a new ResolvableType for uncached purposes, with upfront resolution but lazily calculated hash.

Method Summary

Modifier and Type	Method and Description
ResolvableType	as(java.lang.Class<?> type) Return this type as a ResolvableType of the specified class.
ResolvableType	asCollection() Convenience method to return this type as a resolvable Collection type.
ResolvableType	asMap() Convenience method to return this type as a resolvable Map type.
(package private) ResolvableType.VariableResolver	asVariableResolver() Adapts this ResolvableType to a ResolvableType.VariableResolver.
private int	calculateHashCode()
static void	clearCache() Clear the internal ResolvableType/SerializableTypeWrapper cache.
boolean	equals(java.lang.Object other)
static ResolvableType	forArrayComponent(ResolvableType componentType) Return a ResolvableType as a array of the specified componentType.
static ResolvableType	forClass(java.lang.Class<?> clazz) Return a ResolvableType for the specified Class, using the full generic type information for assignability checks.
static ResolvableType	forClass(java.lang.Class<?> baseType, java.lang.Class<?> implementationClass) Return a ResolvableType for the specified base type (interface or base class) with a given implementation class.
static ResolvableType	forClassWithGenerics(java.lang.Class<?> clazz, java.lang.Class<?>... generics) Return a ResolvableType for the specified Class with pre-declared generics.
static ResolvableType	forClassWithGenerics(java.lang.Class<?> clazz, ResolvableType... generics) Return a ResolvableType for the specified Class with pre-declared generics.
static ResolvableType	forConstructorParameter(java.lang.reflect.Constructor<?> constructor, int parameterIndex) Return a ResolvableType for the specified Constructor parameter.
static ResolvableType	forConstructorParameter(java.lang.reflect.Constructor<?> constructor, int parameterIndex, java.lang.Class<?> implementationClass) Return a ResolvableType for the specified Constructor parameter with a given implementation.
static ResolvableType	forField(java.lang.reflect.Field field) Return a ResolvableType for the specified Field.
static ResolvableType	forField(java.lang.reflect.Field field, java.lang.Class<?> implementationClass) Return a ResolvableType for the specified Field with a given implementation.
static ResolvableType	forField(java.lang.reflect.Field field, int nestingLevel) Return a ResolvableType for the specified Field with the given nesting level.
static ResolvableType	forField(java.lang.reflect.Field field, int nestingLevel, java.lang.Class<?> implementationClass) Return a ResolvableType for the specified Field with a given implementation and the given nesting level.
static ResolvableType	forField(java.lang.reflect.Field field, ResolvableType implementationType) Return a ResolvableType for the specified Field with a given implementation.
static ResolvableType	forInstance(java.lang.Object instance) Return a ResolvableType for the specified instance.
static ResolvableType	forMethodParameter(java.lang.reflect.Method method, int parameterIndex) Return a ResolvableType for the specified Method parameter.
static ResolvableType	forMethodParameter(java.lang.reflect.Method method, int parameterIndex, java.lang.Class<?> implementationClass) Return a ResolvableType for the specified Method parameter with a given implementation.
static ResolvableType	forMethodParameter(MethodParameter methodParameter) Return a ResolvableType for the specified MethodParameter.
static ResolvableType	forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType) Return a ResolvableType for the specified MethodParameter with a given implementation type.
static ResolvableType	forMethodParameter(MethodParameter methodParameter, java.lang.reflect.Type targetType) Return a ResolvableType for the specified MethodParameter, overriding the target type to resolve with a specific given type.
static ResolvableType	forMethodReturnType(java.lang.reflect.Method method) Return a ResolvableType for the specified Method return type.
static ResolvableType	forMethodReturnType(java.lang.reflect.Method method, java.lang.Class<?> implementationClass) Return a ResolvableType for the specified Method return type.
static ResolvableType	forRawClass(java.lang.Class<?> clazz) Return a ResolvableType for the specified Class, doing assignability checks against the raw class only (analogous to Class.isAssignableFrom(java.lang.Class<?>), which this serves as a wrapper for.
static ResolvableType	forType(ParameterizedTypeReference<?> typeReference) Return a ResolvableType for the specified ParameterizedTypeReference.
static ResolvableType	forType(java.lang.reflect.Type type) Return a ResolvableType for the specified Type.
(package private) static ResolvableType	forType(java.lang.reflect.Type type, ResolvableType.VariableResolver variableResolver) Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	forType(java.lang.reflect.Type type, ResolvableType owner) Return a ResolvableType for the specified Type backed by the given owner type.
(package private) static ResolvableType	forType(java.lang.reflect.Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver) Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
private static ResolvableType[]	forTypes(java.lang.reflect.Type[] types, ResolvableType.VariableResolver owner)
ResolvableType	getComponentType() Return the ResolvableType representing the component type of the array or NONE if this type does not represent an array.
ResolvableType	getGeneric(int... indexes) Return a ResolvableType representing the generic parameter for the given indexes.
ResolvableType[]	getGenerics() Return an array of ResolvableTypes representing the generic parameters of this type.
ResolvableType[]	getInterfaces() Return a ResolvableType array representing the direct interfaces implemented by this type.
ResolvableType	getNested(int nestingLevel) Return a ResolvableType for the specified nesting level.
ResolvableType	getNested(int nestingLevel, java.util.Map<java.lang.Integer,java.lang.Integer> typeIndexesPerLevel) Return a ResolvableType for the specified nesting level.
java.lang.Class<?>	getRawClass() Return the underlying Java Class being managed, if available; otherwise null.
java.lang.Object	getSource() Return the underlying source of the resolvable type.
ResolvableType	getSuperType() Return a ResolvableType representing the direct supertype of this type.
java.lang.reflect.Type	getType() Return the underling Java Type being managed.
boolean	hasGenerics() Return true if this type contains generic parameters.
int	hashCode()
boolean	hasUnresolvableGenerics() Determine whether the underlying type has any unresolvable generics: either through an unresolvable type variable on the type itself or through implementing a generic interface in a raw fashion, i.e.
boolean	isArray() Return true if this type resolves to a Class that represents an array.
boolean	isAssignableFrom(java.lang.Class<?> other) Determine whether this ResolvableType is assignable from the specified other type.
boolean	isAssignableFrom(ResolvableType other) Determine whether this ResolvableType is assignable from the specified other type.
private boolean	isAssignableFrom(ResolvableType other, java.util.Map<java.lang.reflect.Type,java.lang.reflect.Type> matchedBefore)
(package private) boolean	isEntirelyUnresolvable() Return true if this type contains unresolvable generics only, that is, no substitute for any of its declared type variables.
boolean	isInstance(java.lang.Object obj) Determine whether the given object is an instance of this ResolvableType.
private boolean	isUnresolvableTypeVariable() Determine whether the underlying type is a type variable that cannot be resolved through the associated variable resolver.
private boolean	isWildcardWithoutBounds() Determine whether the underlying type represents a wildcard without specific bounds (i.e., equal to ? extends Object).
private java.lang.Object	readResolve() Custom serialization support for NONE.
java.lang.Class<?>	resolve() Resolve this type to a Class, returning null if the type cannot be resolved.
java.lang.Class<?>	resolve(java.lang.Class<?> fallback) Resolve this type to a Class, returning the specified fallback if the type cannot be resolved.
private java.lang.reflect.Type	resolveBounds(java.lang.reflect.Type[] bounds)
private java.lang.Class<?>	resolveClass()
java.lang.Class<?>	resolveGeneric(int... indexes) Convenience method that will get and resolve a specific generic parameters.
java.lang.Class<?>[]	resolveGenerics() Convenience method that will get and resolve generic parameters.
java.lang.Class<?>[]	resolveGenerics(java.lang.Class<?> fallback) Convenience method that will get and resolve generic parameters, using the specified fallback if any type cannot be resolved.
(package private) static void	resolveMethodParameter(MethodParameter methodParameter) Resolve the top-level parameter type of the given MethodParameter.
(package private) ResolvableType	resolveType() Resolve this type by a single level, returning the resolved value or NONE.
private ResolvableType	resolveVariable(java.lang.reflect.TypeVariable<?> variable)
java.lang.String	toString() Return a String representation of this type in its fully resolved form (including any generic parameters).

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

NONE

public static final ResolvableType NONE

ResolvableType returned when no value is available. NONE is used in preference to null so that multiple method calls can be safely chained.

EMPTY_TYPES_ARRAY

private static final ResolvableType[] EMPTY_TYPES_ARRAY

cache

private static final ConcurrentReferenceHashMap<ResolvableType,ResolvableType> cache

type

private final java.lang.reflect.Type type

The underlying Java type being managed.

typeProvider

@Nullable
private final SerializableTypeWrapper.TypeProvider typeProvider

Optional provider for the type.

variableResolver

@Nullable
private final ResolvableType.VariableResolver variableResolver

The VariableResolver to use or null if no resolver is available.

componentType

@Nullable
private final ResolvableType componentType

The component type for an array or null if the type should be deduced.

hash

@Nullable
private final java.lang.Integer hash

resolved

@Nullable
private java.lang.Class<?> resolved

superType

@Nullable
private volatile ResolvableType superType

interfaces

@Nullable
private volatile ResolvableType[] interfaces

generics

@Nullable
private volatile ResolvableType[] generics

Constructor Detail

ResolvableType

private ResolvableType(java.lang.reflect.Type type,
                       @Nullable
                       SerializableTypeWrapper.TypeProvider typeProvider,
                       @Nullable
                       ResolvableType.VariableResolver variableResolver)

Private constructor used to create a new ResolvableType for cache key purposes, with no upfront resolution.

ResolvableType

private ResolvableType(java.lang.reflect.Type type,
                       @Nullable
                       SerializableTypeWrapper.TypeProvider typeProvider,
                       @Nullable
                       ResolvableType.VariableResolver variableResolver,
                       @Nullable
                       java.lang.Integer hash)

Private constructor used to create a new ResolvableType for cache value purposes, with upfront resolution and a pre-calculated hash.

Since:

4.2

ResolvableType

private ResolvableType(java.lang.reflect.Type type,
                       @Nullable
                       SerializableTypeWrapper.TypeProvider typeProvider,
                       @Nullable
                       ResolvableType.VariableResolver variableResolver,
                       @Nullable
                       ResolvableType componentType)

Private constructor used to create a new ResolvableType for uncached purposes, with upfront resolution but lazily calculated hash.

ResolvableType

private ResolvableType(@Nullable
                       java.lang.Class<?> clazz)

Private constructor used to create a new ResolvableType on a Class basis. Avoids all instanceof checks in order to create a straight Class wrapper.

Since:

4.2

Method Detail

getType

public java.lang.reflect.Type getType()

Return the underling Java Type being managed.

getRawClass

@Nullable
public java.lang.Class<?> getRawClass()

Return the underlying Java Class being managed, if available; otherwise null.

getSource

public java.lang.Object getSource()

Return the underlying source of the resolvable type. Will return a Field, MethodParameter or Type depending on how the ResolvableType was constructed. With the exception of the NONE constant, this method will never return null. This method is primarily to provide access to additional type information or meta-data that alternative JVM languages may provide.

isInstance

public boolean isInstance(@Nullable
                          java.lang.Object obj)

Determine whether the given object is an instance of this ResolvableType.

Parameters:

obj - the object to check

Since:

4.2

See Also:

isAssignableFrom(Class)

isAssignableFrom

public boolean isAssignableFrom(java.lang.Class<?> other)

Determine whether this ResolvableType is assignable from the specified other type.

Parameters:

other - the type to be checked against (as a Class)

Since:

4.2

See Also:

isAssignableFrom(ResolvableType)

isAssignableFrom

public boolean isAssignableFrom(ResolvableType other)

Determine whether this ResolvableType is assignable from the specified other type.

Attempts to follow the same rules as the Java compiler, considering whether both the resolved Class is assignable from the given type as well as whether all generics are assignable.

Parameters:

other - the type to be checked against (as a ResolvableType)

Returns:

true if the specified other type can be assigned to this ResolvableType; false otherwise

isAssignableFrom

private boolean isAssignableFrom(ResolvableType other,
                                 @Nullable
                                 java.util.Map<java.lang.reflect.Type,java.lang.reflect.Type> matchedBefore)

isArray

public boolean isArray()

Return true if this type resolves to a Class that represents an array.

See Also:

getComponentType()

getComponentType

public ResolvableType getComponentType()

Return the ResolvableType representing the component type of the array or NONE if this type does not represent an array.

See Also:

isArray()

asCollection

public ResolvableType asCollection()

Convenience method to return this type as a resolvable Collection type. Returns NONE if this type does not implement or extend Collection.

See Also:

as(Class), asMap()

asMap

public ResolvableType asMap()

Convenience method to return this type as a resolvable Map type. Returns NONE if this type does not implement or extend Map.

See Also:

as(Class), asCollection()

as

public ResolvableType as(java.lang.Class<?> type)

Return this type as a ResolvableType of the specified class. Searches supertype and interface hierarchies to find a match, returning NONE if this type does not implement or extend the specified class.

Parameters:

type - the required type (typically narrowed)

Returns:

a ResolvableType representing this object as the specified type, or NONE if not resolvable as that type

See Also:

asCollection(), asMap(), getSuperType(), getInterfaces()

getSuperType

public ResolvableType getSuperType()

Return a ResolvableType representing the direct supertype of this type. If no supertype is available this method returns NONE.

See Also:

getInterfaces()

getInterfaces

public ResolvableType[] getInterfaces()

Return a ResolvableType array representing the direct interfaces implemented by this type. If this type does not implement any interfaces an empty array is returned.

See Also:

getSuperType()

hasGenerics

public boolean hasGenerics()

Return true if this type contains generic parameters.

See Also:

getGeneric(int...), getGenerics()

isEntirelyUnresolvable

boolean isEntirelyUnresolvable()

Return true if this type contains unresolvable generics only, that is, no substitute for any of its declared type variables.

hasUnresolvableGenerics

public boolean hasUnresolvableGenerics()

Determine whether the underlying type has any unresolvable generics: either through an unresolvable type variable on the type itself or through implementing a generic interface in a raw fashion, i.e. without substituting that interface's type variables. The result will be true only in those two scenarios.

isUnresolvableTypeVariable

private boolean isUnresolvableTypeVariable()

Determine whether the underlying type is a type variable that cannot be resolved through the associated variable resolver.

isWildcardWithoutBounds

private boolean isWildcardWithoutBounds()

Determine whether the underlying type represents a wildcard without specific bounds (i.e., equal to ? extends Object).

getNested

public ResolvableType getNested(int nestingLevel)

Return a ResolvableType for the specified nesting level. See getNested(int, Map) for details.

Parameters:

nestingLevel - the nesting level

Returns:

the ResolvableType type, or #NONE

getNested

public ResolvableType getNested(int nestingLevel,
                                @Nullable
                                java.util.Map<java.lang.Integer,java.lang.Integer> typeIndexesPerLevel)

Return a ResolvableType for the specified nesting level. The nesting level refers to the specific generic parameter that should be returned. A nesting level of 1 indicates this type; 2 indicates the first nested generic; 3 the second; and so on. For example, given List<Set<Integer>> level 1 refers to the List, level 2 the Set, and level 3 the Integer.

The typeIndexesPerLevel map can be used to reference a specific generic for the given level. For example, an index of 0 would refer to a Map key; whereas, 1 would refer to the value. If the map does not contain a value for a specific level the last generic will be used (e.g. a Map value).

Nesting levels may also apply to array types; for example given String[], a nesting level of 2 refers to String.

If a type does not contain generics the supertype hierarchy will be considered.

Parameters:

nestingLevel - the required nesting level, indexed from 1 for the current type, 2 for the first nested generic, 3 for the second and so on

typeIndexesPerLevel - a map containing the generic index for a given nesting level (may be null)

Returns:

a ResolvableType for the nested level or NONE

getGeneric

public ResolvableType getGeneric(@Nullable
                                 int... indexes)

Return a ResolvableType representing the generic parameter for the given indexes. Indexes are zero based; for example given the type Map<Integer, List<String>>, getGeneric(0) will access the Integer. Nested generics can be accessed by specifying multiple indexes; for example getGeneric(1, 0) will access the String from the nested List. For convenience, if no indexes are specified the first generic is returned.

If no generic is available at the specified indexes NONE is returned.

Parameters:

indexes - the indexes that refer to the generic parameter (may be omitted to return the first generic)

Returns:

a ResolvableType for the specified generic or NONE

See Also:

hasGenerics(), getGenerics(), resolveGeneric(int...), resolveGenerics()

getGenerics

public ResolvableType[] getGenerics()

Return an array of ResolvableTypes representing the generic parameters of this type. If no generics are available an empty array is returned. If you need to access a specific generic consider using the getGeneric(int...) method as it allows access to nested generics and protects against IndexOutOfBoundsExceptions.

Returns:

an array of ResolvableTypes representing the generic parameters (never null)

See Also:

hasGenerics(), getGeneric(int...), resolveGeneric(int...), resolveGenerics()

resolveGenerics

public java.lang.Class<?>[] resolveGenerics()

Convenience method that will get and resolve generic parameters.

Returns:

an array of resolved generic parameters (the resulting array will never be null, but it may contain null elements})

See Also:

getGenerics(), resolve()

resolveGenerics

public java.lang.Class<?>[] resolveGenerics(java.lang.Class<?> fallback)

Convenience method that will get and resolve generic parameters, using the specified fallback if any type cannot be resolved.

Parameters:

fallback - the fallback class to use if resolution fails

Returns:

an array of resolved generic parameters

See Also:

getGenerics(), resolve()

resolveGeneric

@Nullable
public java.lang.Class<?> resolveGeneric(int... indexes)

Convenience method that will get and resolve a specific generic parameters.

Parameters:

indexes - the indexes that refer to the generic parameter (may be omitted to return the first generic)

Returns:

a resolved Class or null

See Also:

getGeneric(int...), resolve()

resolve

@Nullable
public java.lang.Class<?> resolve()

Resolve this type to a Class, returning null if the type cannot be resolved. This method will consider bounds of TypeVariables and WildcardTypes if direct resolution fails; however, bounds of Object.class will be ignored.

Returns:

the resolved Class, or null if not resolvable

See Also:

resolve(Class), resolveGeneric(int...), resolveGenerics()

resolve

public java.lang.Class<?> resolve(java.lang.Class<?> fallback)

Resolve this type to a Class, returning the specified fallback if the type cannot be resolved. This method will consider bounds of TypeVariables and WildcardTypes if direct resolution fails; however, bounds of Object.class will be ignored.

Parameters:

fallback - the fallback class to use if resolution fails

Returns:

the resolved Class or the fallback

See Also:

resolve(), resolveGeneric(int...), resolveGenerics()

resolveClass

@Nullable
private java.lang.Class<?> resolveClass()

resolveType

ResolvableType resolveType()

Resolve this type by a single level, returning the resolved value or NONE.

Note: The returned ResolvableType should only be used as an intermediary as it cannot be serialized.

resolveBounds

@Nullable
private java.lang.reflect.Type resolveBounds(java.lang.reflect.Type[] bounds)

resolveVariable

@Nullable
private ResolvableType resolveVariable(java.lang.reflect.TypeVariable<?> variable)

equals

public boolean equals(java.lang.Object other)

Overrides:

equals in class java.lang.Object

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

calculateHashCode

private int calculateHashCode()

asVariableResolver

@Nullable
ResolvableType.VariableResolver asVariableResolver()

Adapts this ResolvableType to a ResolvableType.VariableResolver.

readResolve

private java.lang.Object readResolve()

Custom serialization support for NONE.

toString

public java.lang.String toString()

Return a String representation of this type in its fully resolved form (including any generic parameters).

Overrides:

toString in class java.lang.Object

forClass

public static ResolvableType forClass(@Nullable
                                      java.lang.Class<?> clazz)

Return a ResolvableType for the specified Class, using the full generic type information for assignability checks. For example: ResolvableType.forClass(MyArrayList.class).

Parameters:

clazz - the class to introspect (null is semantically equivalent to Object.class for typical use cases here}

Returns:

a ResolvableType for the specified class

See Also:

forClass(Class, Class), forClassWithGenerics(Class, Class...)

forRawClass

public static ResolvableType forRawClass(@Nullable
                                         java.lang.Class<?> clazz)

Return a ResolvableType for the specified Class, doing assignability checks against the raw class only (analogous to Class.isAssignableFrom(java.lang.Class<?>), which this serves as a wrapper for. For example: ResolvableType.forRawClass(List.class).

Parameters:

clazz - the class to introspect (null is semantically equivalent to Object.class for typical use cases here}

Returns:

a ResolvableType for the specified class

Since:

4.2

See Also:

forClass(Class), getRawClass()

forClass

public static ResolvableType forClass(java.lang.Class<?> baseType,
                                      java.lang.Class<?> implementationClass)

Return a ResolvableType for the specified base type (interface or base class) with a given implementation class. For example: ResolvableType.forClass(List.class, MyArrayList.class).

Parameters:

baseType - the base type (must not be null)

implementationClass - the implementation class

Returns:

a ResolvableType for the specified base type backed by the given implementation class

See Also:

forClass(Class), forClassWithGenerics(Class, Class...)

forClassWithGenerics

public static ResolvableType forClassWithGenerics(java.lang.Class<?> clazz,
                                                  java.lang.Class<?>... generics)

Return a ResolvableType for the specified Class with pre-declared generics.

Parameters:

clazz - the class (or interface) to introspect

generics - the generics of the class

Returns:

a ResolvableType for the specific class and generics

See Also:

forClassWithGenerics(Class, ResolvableType...)

forClassWithGenerics

public static ResolvableType forClassWithGenerics(java.lang.Class<?> clazz,
                                                  ResolvableType... generics)

Return a ResolvableType for the specified Class with pre-declared generics.

Parameters:

clazz - the class (or interface) to introspect

generics - the generics of the class

Returns:

a ResolvableType for the specific class and generics

See Also:

forClassWithGenerics(Class, Class...)

forInstance

public static ResolvableType forInstance(java.lang.Object instance)

Return a ResolvableType for the specified instance. The instance does not convey generic information but if it implements ResolvableTypeProvider a more precise ResolvableType can be used than the simple one based on the Class instance.

Parameters:

instance - the instance

Returns:

a ResolvableType for the specified instance

Since:

4.2

See Also:

ResolvableTypeProvider

forField

public static ResolvableType forField(java.lang.reflect.Field field)

Return a ResolvableType for the specified Field.

Parameters:

field - the source field

Returns:

a ResolvableType for the specified field

See Also:

forField(Field, Class)

forField

public static ResolvableType forField(java.lang.reflect.Field field,
                                      java.lang.Class<?> implementationClass)

Return a ResolvableType for the specified Field with a given implementation.

Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.

Parameters:

field - the source field

implementationClass - the implementation class

Returns:

a ResolvableType for the specified field

See Also:

forField(Field)

forField

public static ResolvableType forField(java.lang.reflect.Field field,
                                      @Nullable
                                      ResolvableType implementationType)

Return a ResolvableType for the specified Field with a given implementation.

Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation type.

Parameters:

field - the source field

implementationType - the implementation type

Returns:

a ResolvableType for the specified field

See Also:

forField(Field)

forField

public static ResolvableType forField(java.lang.reflect.Field field,
                                      int nestingLevel)

Return a ResolvableType for the specified Field with the given nesting level.

Parameters:

field - the source field

nestingLevel - the nesting level (1 for the outer level; 2 for a nested generic type; etc)

See Also:

forField(Field)

forField

public static ResolvableType forField(java.lang.reflect.Field field,
                                      int nestingLevel,
                                      @Nullable
                                      java.lang.Class<?> implementationClass)

Return a ResolvableType for the specified Field with a given implementation and the given nesting level.

Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.

Parameters:

field - the source field

nestingLevel - the nesting level (1 for the outer level; 2 for a nested generic type; etc)

implementationClass - the implementation class

Returns:

a ResolvableType for the specified field

See Also:

forField(Field)

forConstructorParameter

public static ResolvableType forConstructorParameter(java.lang.reflect.Constructor<?> constructor,
                                                     int parameterIndex)

Return a ResolvableType for the specified Constructor parameter.

Parameters:

constructor - the source constructor (must not be null)

parameterIndex - the parameter index

Returns:

a ResolvableType for the specified constructor parameter

See Also:

forConstructorParameter(Constructor, int, Class)

forConstructorParameter

public static ResolvableType forConstructorParameter(java.lang.reflect.Constructor<?> constructor,
                                                     int parameterIndex,
                                                     java.lang.Class<?> implementationClass)

Return a ResolvableType for the specified Constructor parameter with a given implementation. Use this variant when the class that declares the constructor includes generic parameter variables that are satisfied by the implementation class.

Parameters:

constructor - the source constructor (must not be null)

parameterIndex - the parameter index

implementationClass - the implementation class

Returns:

a ResolvableType for the specified constructor parameter

See Also:

forConstructorParameter(Constructor, int)

forMethodReturnType

public static ResolvableType forMethodReturnType(java.lang.reflect.Method method)

Return a ResolvableType for the specified Method return type.

Parameters:

method - the source for the method return type

Returns:

a ResolvableType for the specified method return

See Also:

forMethodReturnType(Method, Class)

forMethodReturnType

public static ResolvableType forMethodReturnType(java.lang.reflect.Method method,
                                                 java.lang.Class<?> implementationClass)

Return a ResolvableType for the specified Method return type. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation class.

Parameters:

method - the source for the method return type

implementationClass - the implementation class

Returns:

a ResolvableType for the specified method return

See Also:

forMethodReturnType(Method)

forMethodParameter

public static ResolvableType forMethodParameter(java.lang.reflect.Method method,
                                                int parameterIndex)

Return a ResolvableType for the specified Method parameter.

Parameters:

method - the source method (must not be null)

parameterIndex - the parameter index

Returns:

a ResolvableType for the specified method parameter

See Also:

forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)

forMethodParameter

public static ResolvableType forMethodParameter(java.lang.reflect.Method method,
                                                int parameterIndex,
                                                java.lang.Class<?> implementationClass)

Return a ResolvableType for the specified Method parameter with a given implementation. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation class.

Parameters:

method - the source method (must not be null)

parameterIndex - the parameter index

implementationClass - the implementation class

Returns:

a ResolvableType for the specified method parameter

See Also:

forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)

forMethodParameter

public static ResolvableType forMethodParameter(MethodParameter methodParameter)

Return a ResolvableType for the specified MethodParameter.

Parameters:

methodParameter - the source method parameter (must not be null)

Returns:

a ResolvableType for the specified method parameter

See Also:

forMethodParameter(Method, int)

forMethodParameter

public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                @Nullable
                                                ResolvableType implementationType)

Return a ResolvableType for the specified MethodParameter with a given implementation type. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation type.

Parameters:

methodParameter - the source method parameter (must not be null)

implementationType - the implementation type

Returns:

a ResolvableType for the specified method parameter

See Also:

forMethodParameter(MethodParameter)

forMethodParameter

public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                @Nullable
                                                java.lang.reflect.Type targetType)

Return a ResolvableType for the specified MethodParameter, overriding the target type to resolve with a specific given type.

Parameters:

methodParameter - the source method parameter (must not be null)

targetType - the type to resolve (a part of the method parameter's type)

Returns:

a ResolvableType for the specified method parameter

See Also:

forMethodParameter(Method, int)

resolveMethodParameter

static void resolveMethodParameter(MethodParameter methodParameter)

Resolve the top-level parameter type of the given MethodParameter.

Parameters:

methodParameter - the method parameter to resolve

Since:

4.1.9

See Also:

MethodParameter.setParameterType(java.lang.Class<?>)

forArrayComponent

public static ResolvableType forArrayComponent(ResolvableType componentType)

Return a ResolvableType as a array of the specified componentType.

Parameters:

componentType - the component type

Returns:

a ResolvableType as an array of the specified component type

forTypes

private static ResolvableType[] forTypes(java.lang.reflect.Type[] types,
                                         @Nullable
                                         ResolvableType.VariableResolver owner)

forType

public static ResolvableType forType(@Nullable
                                     java.lang.reflect.Type type)

Return a ResolvableType for the specified Type. Note: The resulting ResolvableType may not be Serializable.

Parameters:

type - the source type (potentially null)

Returns:

a ResolvableType for the specified Type

See Also:

forType(Type, ResolvableType)

forType

public static ResolvableType forType(@Nullable
                                     java.lang.reflect.Type type,
                                     @Nullable
                                     ResolvableType owner)

Return a ResolvableType for the specified Type backed by the given owner type. Note: The resulting ResolvableType may not be Serializable.

Parameters:

type - the source type or null

owner - the owner type used to resolve variables

Returns:

a ResolvableType for the specified Type and owner

See Also:

forType(Type)

forType

public static ResolvableType forType(ParameterizedTypeReference<?> typeReference)

Return a ResolvableType for the specified ParameterizedTypeReference. Note: The resulting ResolvableType may not be Serializable.

Parameters:

typeReference - the reference to obtain the source type from

Returns:

a ResolvableType for the specified ParameterizedTypeReference

Since:

4.3.12

See Also:

forType(Type)

forType

static ResolvableType forType(@Nullable
                              java.lang.reflect.Type type,
                              @Nullable
                              ResolvableType.VariableResolver variableResolver)

Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.

Parameters:

type - the source type or null

variableResolver - the variable resolver or null

Returns:

a ResolvableType for the specified Type and ResolvableType.VariableResolver

forType

static ResolvableType forType(@Nullable
                              java.lang.reflect.Type type,
                              @Nullable
                              SerializableTypeWrapper.TypeProvider typeProvider,
                              @Nullable
                              ResolvableType.VariableResolver variableResolver)

Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.

Parameters:

type - the source type or null

typeProvider - the type provider or null

variableResolver - the variable resolver or null

Returns:

a ResolvableType for the specified Type and ResolvableType.VariableResolver

clearCache

public static void clearCache()

Clear the internal ResolvableType/SerializableTypeWrapper cache.

Since:

4.2